﻿#include "thickwiringmac.h"


ThickWiringMac::ThickWiringMac()
{
    //添加各种参数到列表中
    initRootParasList();
    initRootHMIConfigurationList(m_allParasList);//超级用户界面配置
    initPatternsParasList();
    initSoftwareParasList(m_allParasList);
    initTimeParasList(m_allParasList);
    initMcParasList();
    initWkParasList();

    //初始化控制动作列表
    initOutCtrlList();

    //初始化快捷功能列表
    initShortCutList();

    //初始化辅助功能列表
    initAssistList();

    //初始化花样设置功能列表
    initPatternSetList();

    //参数分类功能
    initParaSetList();

    //初始化传感器列表
    initSensorList();

    //初始化错误代码和状态列表
    initErrorCodeAndStateList();

    //初始化九宫格
    initNinebtn1234();

    //加载右上角信息
    initFileInfoLabel();
}

ThickWiringMac::~ThickWiringMac()
{

}

void ThickWiringMac::initNinebtn1234()
{
    m_nineBtn.insert(1,NineItem(FUN_HEAD_LIFTUPDOWN,"buttonHeadLifting"));      //机头升降
//    m_nineBtn.insert(2,NineItem(FUN_MANUAL_THREAD_CUTTING,"buttonMunualThreadCutting"));
    m_nineBtn.insert(2,NineItem(FUN_CUT_UD,"buttonMunualThreadCutting"));       //剪底面线
    m_nineBtn.insert(3,NineItem(FUN_PROCESSRESET,"buttonProcessReset"));
    m_nineBtn.insert(4,NineItem(FUN_SIMULATED_STATUS,"buttonSimulatedStatus"));
}

void ThickWiringMac::initFileInfoLabel()
{
    m_fileInfo.append(FileName);
    m_fileInfo.append(Index);
    m_fileInfo.append(BeginPoint);
    m_fileInfo.append(Range);
    m_fileInfo.append(Position);
    m_fileInfo.append(Production);
}

void ThickWiringMac::initPatternsParasList()
{
    int index = 0; //按顺序排列，想要更改顺序只需要修改代码位置
//    QTextCodec *cod = QTextCodec::codecForLocale();

    //花样参数-花样设置参数-针步大小；单位：毫米 ，范围20-80，默认20
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_PATTERN,
                                        PATTERNPARA_SORT_DSTR | PATTERNPARA_SORT_QUI,
                                        SET_SETSTEPSIZE, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Step size"),//针步大小
                                        20, 20, 80, 20, 1, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, index++, operate));

//    //花样参数-花样设置参数-缩放x；单位：毫米 ，范围0-20000，默认0
//    m_allParasList.append(makeAParaItem(0,
//                                        PARA_TYPE_PATTERN,
//                                        PATTERNPARA_SORT_DSTR | PATTERNPARA_SORT_QUI,
//                                        SET_SCANX, 0, 0, PARA_VALUE_TYPE_INT,
//                                        tr("Width"),//宽度
//                                        5000, 0, 20000, 0, 1, tr("mm"), tr(""),
//                                        tr(""),
//                                        0, 0, index++, operate));

//    //花样参数-花样设置参数-缩放y；单位：毫米 ，范围0-20000，默认0
//    m_allParasList.append(makeAParaItem(0,
//                                        PARA_TYPE_PATTERN,
//                                        PATTERNPARA_SORT_DSTR | PATTERNPARA_SORT_QUI,
//                                        SET_SCANY, 0, 0, PARA_VALUE_TYPE_INT,
//                                        tr("Height"),//高度
//                                        5000, 0, 20000, 0, 1, tr("mm"), tr(""),
//                                        tr(""),
//                                        0, 0, index++, operate));

    //花样参数-花样设置参数-起始点x；范围-1000000--1000000，单位0.01mm，默认 0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_PATTERN,
                                        PATTERNPARA_SORT_DSTR ,
                                        SET_STARTX, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("startX"),//起始点X
                                        0, -1000000, 1000000, 0, 2, tr("mm"), tr(""),//mm
                                        tr(""), 0, 0,0x0003, operate));

    //花样参数-花样设置参数-起始点y；范围-1000000--1000000，单位0.01mm，默认 0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_PATTERN,
                                        PATTERNPARA_SORT_DSTR ,
                                        SET_STARTY, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("startrY"),//起始点Y
                                        0, -1000000, 1000000, 0, 2, tr("mm"), tr(""),//mm
                                        tr(""), 0, 0,0x0004, operate));

    //花样参数-花样设置参数-翻转式样；单位：无 ，范围0-7，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_PATTERN,
                                        PATTERNPARA_SORT_DSTR,
                                        SET_ROTATESTYLE, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Flip style"),//翻转式样
                                        0, 0, 7, 0, 0, tr(""), tr(""),
                                        tr("normalP:0;nRight90P:1;nRight180P:2;nRight270P:3;mirrorP:4;mRight90P:5;mRight180P:6;mRight270P:7"),
                                        0, 0, 0x0005, operate));

    //花样参数-花样设置参数-平分距离；单位：毫米 ，范围0-20000，默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_PATTERN,
                                        PATTERNPARA_SORT_DSTR,
                                        SET_BISECT, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Divide the distance equally"),//高度
                                        0, 0, 20000, 0, 0, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0006, operate));

//    //花样参数-花样设置参数-旋转角度；单位：° ，范围0-90，默认0
//    m_allParasList.append(makeAParaItem(0,
//                                        PARA_TYPE_PATTERN,
//                                        PATTERNPARA_SORT_DSTR,
//                                        SET_ROTATEANGLE, 0, 0, PARA_VALUE_TYPE_INT,
//                                        tr("Rotation angle"),//旋转角度
//                                        0, 0, 90, 0, 0, cod->toUnicode("°"), tr(""),//度
//                                        tr(""), 0, 0,0x0006, operate));

//    //花样参数-花样设置参数-等比缩放
//    m_allParasList.append(makeAParaItem(0,
//                                        PARA_TYPE_PATTERN,
//                                        PATTERNPARA_SORT_QUI,
//                                        SET_EQUAL, 0, 0, PARA_VALUE_TYPE_SW,
//                                        tr("Equal ratio"),//等比缩放
//                                        1, 0, 1, 1, 0, tr(""), tr(""),
//                                        tr(""),
//                                        0, 0, index++, operate));


}

void ThickWiringMac::initMcParasList()
{
    QTextCodec *cod = QTextCodec::codecForLocale();
    // 主轴停车传感器角度,范围0--10000,  单位 0.01度，默认 400
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SETTING,
                                        19, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle parking sensor angle"),//主轴停车传感器角度
                                        400, 0, 10000, 400, 2, cod->toUnicode("°"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 上旋转找零补偿,范围-1000--1000,  单位 0.01度，默认 400
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SETTING,
                                        20, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Upward rotation zero compensation"),//上旋转找零补偿
                                        400, -1000, 1000, 400, 2, cod->toUnicode("°"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 下旋转找零补偿,范围-1000--1000,  单位 0.01度，默认 400
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SETTING,
                                        21, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Downward rotation zero compensation"),//下旋转找零补偿
                                        400, -1000, 1000, 400, 2, cod->toUnicode("°"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 主轴找零补偿, 范围-1000--1000,  单位 0.01度，默认 400
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SETTING,
                                        22, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle zero compensation"),//主轴找零补偿
                                        400, -1000, 1000, 400, 2, cod->toUnicode("°"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 画笔相对位置X,单位0.01mm, 范围 -2147483648--2147483647
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SETTING,
                                        23, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Brush relative position X"),//画笔相对位置X
                                        0, S32_MIN, S32_MAX, 0, 2, "mm", tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 画笔相对位置Y,单位0.01mm, 范围 -2147483648--2147483647
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SETTING,
                                        24, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Brush relative position Y"),//画笔相对位置Y
                                        0, S32_MIN, S32_MAX, 0, 2, "mm", tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // X框传感器坐标，单位 0.01mm
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SETTING,
                                        25, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("X-box sensor coordinates"),//X框传感器坐标
                                        0, S32_MIN, S32_MAX, 0, 2, "mm", tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // Y框传感器坐标，单位 0.01mm
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SETTING,
                                        26, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Y-box sensor coordinates"),//Y框传感器坐标
                                        0, S32_MIN, S32_MAX, 0, 2, "mm", tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 自动换梭装置	0,无		1,日本	2,富怡
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SETTING,
                                        27, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Automatic shuttle changing device"),// 自动换梭装置
                                        0, 0, 2, 0, 0, tr(""), tr(""),
                                        tr("No:0;Japan:1;RichPeace:2"),//0,无  1,日本	2,富怡
                                        0, 0, 0x0001, operate));
    // 夹布开合延时,单位0.1秒,默认5,范围1-30
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SETTING,
                                        28, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Delay in opening and closing with fabric clamp"),// 夹布开合延时
                                        5, 1, 100, 5, 1, tr("s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 画笔下降延时,单位0.1秒,默认5,范围1-30
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SETTING,
                                        29, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Brush descent delay"),// 画笔下降延时
                                        5, 1, 50, 5, 1, tr("s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    // 40
    // 可移动区域(X-), 范围 -2147483648--2147483647，单位0.01mm
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        40, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Movable area (X -)"),//可移动区域(X-)
                                        0, S32_MIN, S32_MAX, 0, 2, "mm", tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    // 可移动区域(X+), 范围 -2147483648--2147483647，单位0.01mm
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        41, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Movable area (X +)"),//可移动区域(X+)
                                        0, S32_MIN, S32_MAX, 0, 2, "mm", tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    // 可移动区域(Y-), 范围 -2147483648--2147483647，单位0.01mm
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        42, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Movable area (Y-)"),//可移动区域(Y-)
                                        0, S32_MIN, S32_MAX, 0, 2, "mm", tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    // 可移动区域(Y+), 范围 -2147483648--2147483647，单位0.01mm
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        43, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Movable area (Y+)"),//可移动区域(Y+)
                                        0, S32_MIN, S32_MAX, 0, 2, "mm", tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    //44
    QString workableArea = tr("Workable area ");
    // 可工作区域(X-), 范围 -2147483648--2147483647，单位0.01mm
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        44, 0, 0, PARA_VALUE_TYPE_INT,
                                        workableArea + "(X-)",//可工作区域(X-)
                                        0, S32_MIN, S32_MAX, 0, 2, "mm", tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 可工作区域(X+), 范围 -2147483648--2147483647，单位0.01mm
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        45, 0, 0, PARA_VALUE_TYPE_INT,
                                        workableArea + "(X+)",//可工作区域(X+)
                                        0, S32_MIN, S32_MAX, 0, 2, "mm", tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 可工作区域(Y-), 范围 -2147483648--2147483647，单位0.01mm
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        46, 0, 0, PARA_VALUE_TYPE_INT,
                                        workableArea + "(Y-)",//可工作区域(Y-)
                                        0, S32_MIN, S32_MAX, 0, 2, "mm", tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 可工作区域(Y+), 范围 -2147483648--2147483647，单位0.01mm
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_POSITION,
                                        47, 0, 0, PARA_VALUE_TYPE_INT,
                                        workableArea + "(Y+)",//可工作区域(Y+)
                                        0, S32_MIN, S32_MAX, 0, 2, "mm", tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // X向气框长度, 范围 1000--2000,单位mm,默认1000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SETTING,
                                        48, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("X-direction air frame length"),// X-direction air frame length
                                        1000, 1000, 2000, 1000, 0, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    // 79
    // XY归零运行速度, 范围 1--100，单位mm/s，默认 100
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        79, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("XY zero running speed"),//XY归零运行速度
                                        100, 1, 100, 100, 0, "mm/s", tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // XY空走运行速度, 范围 100--500,单位mm/s，默认 200
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        80, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("XY idle running speed"),//XY空走运行速度
                                        200, 100, 500, 200, 0, "mm/s", tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // xy手动移动速度1, 范围 10--50，单位mm/s，默认 10
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        81, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Xy manual movement speed 1"),//xy手动移动速度1
                                        10, 10, 50, 10, 0, "mm/s", tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // xy手动移动速度2, 范围 50--200，单位mm/s，默认 100
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        82, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Xy manual movement speed 2"),//xy手动移动速度2
                                        100, 50, 200, 100, 0, "mm/s", tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // xy手动移动速度3, 范围 200--500，单位mm/s，默认 200
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        83, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Xy manual movement speed 3"),//xy手动移动速度3
                                        200, 200, 500, 200, 0, "mm/s", tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 84
    // 主轴运转转速, 范围 100--300，单位r/min，默认 200
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        84, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle running speed"),//主轴运转转速
                                        200, 100, 300, 200, 0, tr("r/min"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 主轴最高转速, 范围 700--3000，单位r/min，默认 800
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        85, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Maximum spindle speed"),//主轴最高转速
                                        800, 700, 3000, 800, 0, tr("r/min"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 主轴手动移动转速,范围1-50,单位r/min,默认10
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        86, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Manual spindle movement speed"),//主轴手动移动转速
                                        10, 1, 50, 10, 0, tr("r/min"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 87
    // 旋转归零速度,单位deg/s,范围10-200
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        87, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Rotation zeroing speed"),//旋转归零速度
                                        10, 10, 200, 10, 0, tr("deg/s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 旋转电机手动移动速度,范围10-100,单位deg/s,默认50
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        88, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Manual movement speed of rotary motor "),//旋转电机手动移动速度
                                        50, 10, 100, 50, 0, tr("deg/s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 旋转电机空走运行速度,范围 100--720, 单位 deg/s(度/秒)，默认 720
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        89, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Rotating motor idle running speed   "),//旋转电机空走运行速度
                                        720, 100, 720, 720, 0, tr("deg/s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 90
    // 画笔最小绘画速度, 范围 1--100，单位mm/s，默认 10
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        90, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("The minimum drawing speed of the brush"),//画笔最小绘画速度
                                        10, 1, 100, 10, 0, tr("mm/s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 画笔最大绘画速度, 范围 1--1500，单位mm/s，默认 1000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        91, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Maximum painting speed of the brush"),//画笔最大绘画速度
                                        1000, 1, 1500, 1000, 0, tr("mm/s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 画笔绘画加速度, 范围 1--5000，单位mm/s2，默认 500
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        92, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Brush painting acceleration"),//画笔绘画加速度
                                        500, 1, 5000, 500, 0, tr("mm/s2"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 画笔绘画降速最小偏差角度，范围 0--18000，单位 0.01度，默认 3000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        93, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("The minimum deviation angle for brush painting speed reduction"),//画笔绘画降速最小偏差角度
                                        3000, 0, 18000, 3000, 2, cod->toUnicode("°"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 拉料速度,单位mm/s,范围50-200
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        94, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Pulling speed"),//拉料速度
                                        50, 50, 200, 50, 0, tr("mm/s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 机头旋转最高速度, 范围 1--720，单位 deg/s，默认 720
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        95, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Maximum speed of head rotation"),
                                        720, 1, 720, 720, 0, tr("deg/s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // XY启动停止速度, 范围 1--100,单位 mm/s，默认 10
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        96, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("XY start stop speed"),
                                        10, 1, 100, 10, 0, tr("mm/s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // XY行走加速度, 范围 1--10000,单位 mm/s2，默认 2000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        97, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("XY walking acceleration"),
                                        2000, 1, 10000, 2000, 0, tr("mm/s2"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // XY刹车加速度, 范围 1--10000,单位 mm/s2，默认 10000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        98, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("XY brake acceleration"),
                                        2000, 1, 10000, 2000, 0, tr("mm/s2"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 主轴启动停止转速, 范围 1--300,单位 r/min，默认 100
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        99, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle start stop speed"),
                                        100, 1, 300, 100, 0, tr("r/min"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 主轴运转加速度, 范围 1--100,单位 r/ss，默认 50
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        100, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle operating acceleration"),
                                        50, 1, 100, 50, 0, tr("r/ss"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 主轴刹车加速度, 范围 1--100,单位 r/ss，默认 100
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_MACH,
                                        MC_SORT_SPEED,
                                        101, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle brake acceleration"),
                                        100, 1, 100, 100, 0, tr("r/ss"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
}

void ThickWiringMac::initWkParasList()
{
    QTextCodec *cod = QTextCodec::codecForLocale();
    // 主轴工作加速度 单位r/ss,默认20,范围 1-100
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SPEED,
                                        9, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle working acceleration"),
                                        20, 1, 100, 20, 0, tr("r/ss"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 10
    // 降速最大偏差角度,单位度,范围0-180,默认30
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SPEED,
                                        10, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Maximum deviation angle of deceleration"),//降速最大偏差角度
                                        30, 0, 180, 30, 0, cod->toUnicode("°"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 起针慢动针数, 范围0--10，单位 针, ，默认 3
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SPEED,
                                        11, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Starting needle, slow moving needle count"),//起针慢动针数
                                        3, 0, 10, 3, 0, tr("needle"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 主轴工作转速, 范围 100--1000，单位r/min，默认 600
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SPEED,
                                        12, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle working speed"),//主轴工作转速
                                        600, 100, 1000, 600, 0, tr("r/min"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 动框最高速度限制 单位mm/s,默认180,范围50-300
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SPEED,
                                        13, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Maximum speed limit for moving frames"),//动框最高速度限制
                                        180, 50, 300, 180, 0, tr("mm/s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 断线检测针数; 0, 不检测断线; 其他, 断线信号连续针数，默认5,单位针,范围0-30
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_DETECT,
                                        14, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Stitch detect if thread broken"),//断线检测针数
                                        5, 0, 30, 5, 0, tr("needle"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    // 15
    // 主轴剪线转速, 范围 1--200，单位r/min，默认 120
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SPEED,
                                        15, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle thread cutting speed"),// 主轴剪线转速
                                        120, 1, 200, 120, 0, tr("r/min"), tr(""),
                                        tr(""), 0, 0, 0x0001, operate));
    //主轴拐角转速, 范围1-3000，默认1000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SPEED,
                                        16, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle corner speed"),//主轴拐角转速
                                        1000, 1, 3000, 1000, 0, tr("r/min"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    //主轴启动慢动转速, 范围 1--500，单位r/min，默认 200
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SPEED,
                                        17, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Spindle start slow speed"),//主轴启动慢动转速
                                        200, 1, 500, 200, 0, tr("r/min"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    //摆臂动作起始角度,单位0.01度,范围0-36000,默认5000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SPEED,
                                        18, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Starting angle of arm swing action"),//摆臂动作起始角度
                                        5000, 0, 36000, 5000, 2, cod->toUnicode("°"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    // 起针压电阻丝针数，默认3,单位针,范围0-10
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_DETECT,
                                        19, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Starting needle pressure resistance wire number of needles"),//断线检测针数
                                        3, 0, 10, 3, 0, tr("needle"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    // 送电阻丝位移量，默认400,单位,范围0-2000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_DETECT,
                                        20, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Displacement of resistance wire"),//送电阻丝位移量
                                        400, 0, 2000, 400, 0, tr(""), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    // 拉料长度,默认500,单位mm,范围10-3000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_DETECT,
                                        21, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Pulling length"),//拉料长度
                                        500, 10, 3000, 500, 0, tr(""), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    // 联动功能  0，不联动，1 单次 2 循环
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SETTING,
                                        22, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Linkage function "),// 联动功能
                                        0, 0, 2, 0, 0, tr(""), tr(""),
                                        tr("No:0;SingleTime:1;Loop:2"),//不联动:0;单次:1;循环:2
                                        0, 0, 0x0001, operate));


    // 70
    // 换梭芯提醒功能, 0, 不启用该功能; 1, 按针度计数延迟提醒; 2, 按片数计数; 3, 按长度立刻提醒; 默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        70, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Bobbin change reminder function"),// 换梭芯提醒功能
                                        0, 0, 3, 0, 0, tr(""), tr(""),
                                        //0, 不启用该功能; 1, 按针度计数延迟提醒; 2, 按片数计数; 3, 按长度立刻提醒; 默认0
                                        tr("Not enabled:0;Delay reminder by needle count:1;Count by number of slices:2;Immediately reminder by length:3"), 0, 0, 0x0001, operate));

    // 换梭针数计数,单位针,默认10000,范围0-50000000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SPEED,
                                        71, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Count of changing shuttle needles"),//换梭针数计数
                                        10000, 0, 50000000, 10000, 0, tr("needle"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 换梭片数计数, 单位片，默认100,范围0-50000000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SETTING,
                                        72, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Count of shuttle change pieces"),// 换梭片数计数
                                        100, 0, 50000000, 100, 0, tr("piece"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 73
    // 加油方式选择, 0, 不加油; 1, 按工作时间间歇加油; 2, 按工作针数间歇加油; 3, 持续不停加油,默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SETTING,
                                        73, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Refueling method selection"),// 加油方式选择
                                        0, 1, 3, 0, 0, tr(""), tr(""),
                                        // 0, 不加油; 1, 按工作时间间歇加油; 2, 按工作针数间歇加油; 3, 持续不停加油,
                                        tr("not refueling:0;According to worktime:1;According to the stitches number:2;Continuously refueling:3"),0, 0, 0x0001, operate));
    // 加油针数间隔, 单位针, 加油方式为按针数加油时有用，默认 10000,范围0-50000000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SETTING,
                                        74, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Interval between refueling stitches"),// 加油针数间隔
                                        10000, 0, 50000000, 10000, 0, tr("needle"), tr(""),
                                        tr(""),0, 0, 0x0001, operate));

    // 加油时间间隔, 单位分钟, 加油方式为按工作时间加油时有用;默认720,范围0-1440
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        75, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Oiling interval by working time"),//加油时间间隔
                                        720, 0, 1440, 720, 0, tr("min"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 加油持续时长,单位秒,默认3,范围1-10
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        76, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Oiling sustained time"),//加油持续时长
                                        3, 1, 10, 3, 0, tr("s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 77
    // 产量预设, 0, 关闭功能；其余，按照预设产量提示
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SETTING,
                                        77, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Production preset"),// 产量预设
                                        0, 0, S32_MAX, 0, 0, tr(""), tr(""),
                                        tr(""),0, 0, 0x0001, operate));
    //完成后停车位置选择, 0, 当前位置; 1，起点， 2，偏移点,  3，上料点,	默认1
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        78, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Stop position selection after work complete"),//完成后停车位置选择
                                        0, 0, 3, 0, 0, tr(""), tr(""),
                                        //当前位置:0;起始点:1;定位点:2;上料点:3
                                        tr("Current:0;Start:1;Anchor:2;Feeding:3"),
                                        0, 0, 0x0001, operate));

    // 79
    // 吹气方式选择, 0, 不吹气; 1, 按工作时间间歇吹气; 2, 按工作针数间歇吹气; 默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        79, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Selection of blowing method"),//吹气方式选择
                                        0, 0, 3, 0, 0, tr(""), tr(""),
                                        //不吹气:0;按工作时间间歇吹气:1;按工作针数间歇吹气:2
                                        tr("Not blowing air:0;By working hours:1;By the number of working stitches:2"),
                                        0, 0, 0x0001, operate));
    // 吹气针数间隔, 单位针, 吹气方式为按针数吹气时有用，默认 10000,范围0-50000000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        80, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Blowing needle interval"),//吹气针数间隔
                                        10000, 0, 50000000, 10000, 0, tr("needle"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 吹气时间间隔, 单位分钟, 吹气方式为按工作时间吹气时有用;默认720,范围0-1440
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        81, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Blowing time interval"),//吹气时间间隔
                                        720, 0, 1440, 720, 0, tr("min"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 吹气持续时长,单位秒,默认3,范围1-10
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        82, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Blowing duration"),//吹气持续时长
                                        3, 0, 10, 3, 0, tr("s"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));
    // 83
    // 电阻丝料架选择	0,料架1		1,料架2
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        83, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Selection of resistance wire rack"),//电阻丝料架选择
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        //料架1:0;料架2:1
                                        tr("Material rack 1:0;Material rack 2:1"),
                                        0, 0, 0x0001, operate));
    // 拉料压料控制选择	0,左侧开启	1,全部开启
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        84, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Selection of material pulling and pressing control"),//拉料压料控制选择
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        //左侧开启:0;全部开启:1
                                        tr("Left side open:0;Open All:1"),
                                        0, 0, 0x0001, operate));

    // 电阻丝送料补偿,单位%,范围0-1000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        85, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Resistance wire feeding compensation "),//电阻丝送料补偿
                                        0, 0, 1000, 0, 0, tr("%"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    // 电阻丝送料拐角补偿,单位%,范围0-1000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        86, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Resistance wire feeding corner compensation"),//电阻丝送料拐角补偿
                                        0, 0, 1000, 0, 0, tr("%"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, operate));

    // 115
    // 缝纫动框起始角度, 0--36000, 单位 0.01度，默认 28000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SETTING,
                                        115, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Starting angle of sewing frame"),// 缝纫动框起始角度
                                        28000, 0, 36000, 28000, 2, cod->toUnicode("°"), tr(""), //度
                                        tr(""),0, 0, 0x0001, operate));
    // 剪线动框方向, 0, 不动框; 1, 向左; 2, 向前; 3, 向右; 4, 向后
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SETTING,
                                        116, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Thread trimming moving frame direction"),// 剪线动框方向
                                        0, 0, 4, 0, 0, tr(""), tr(""),
                                        tr("Fixed frame:0;Left:1;Forward:2;Right:3;Backward:4"), 0, 0, 0x0001, operate));
    // 剪线动框位移, 1--1000, 单位0.01mm, 默认500
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        117, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Trimming frame displacement"),//剪线动框位移
                                        500, 1, 1000, 500, 2, tr("mm"), tr(""),
                                        tr(""),
                                        0, 0, 0x0001, root));
    // 剪线完成角度，0--36000, 单位 0.01度，默认 6000
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SETTING,
                                        118, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Thread trimming completion angle"),// 剪线完成角度
                                        6000, 0, 36000, 6000, 2, cod->toUnicode("°"), tr(""), //度
                                        tr(""),0, 0, 0x0001, operate));
    //119
    // 剪线时动作允许, 位图选择,
    // bit0,压脚上升允许
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        119, 1, 0, PARA_VALUE_TYPE_SW,
                                        tr("Allow the presser foot to rise during thread cutting"),// 剪线时压脚上升允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr(""), 0, 0, 0x0001, operate));
    // bit1,松线允许
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        119, 2, 0, PARA_VALUE_TYPE_SW,
                                        tr("Allow for loose thread during thread cutting"),// 剪线时松线允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr(""), 0, 0, 0x0001, operate));
    // bit2,退针允许
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        119, 3, 0, PARA_VALUE_TYPE_SW,
                                        tr("Allow needle withdrawal during thread cutting"),// 剪线时退针允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr(""), 0, 0, 0x0001, operate));
    // bit3,夹线允许
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_ACTION,
                                        119, 4, 0, PARA_VALUE_TYPE_SW,
                                        tr("Allowing for wire clamping during wire cutting"),// 剪线时夹线允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr(""), 0, 0, 0x0001, operate));
    // 120
    // 开机动作
    //bit 0 摆臂归零
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SETTING,
                                        120, 1, 0, PARA_VALUE_TYPE_SW,
                                        tr("Zero the swing arm when starting up"),// 开机时摆臂归零
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr(""), 0, 0, 0x0001, operate));
    //bit 1 旋转归零
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SETTING,
                                        120, 2, 0, PARA_VALUE_TYPE_SW,
                                        tr("Rotate to Zero when starting up"),// 开机时旋转归零
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr(""), 0, 0, 0x0001, operate));
    // 121
    // 安全输入允许，位图选择，0, 不允许; 1, 允许;
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_DETECT,
                                        121, 1, 0, PARA_VALUE_TYPE_SW,
                                        tr("Safety input pressure allowed"),// 安全输入气压允许
                                        1, 0, 1, 1, 0, tr(""), tr(""),
                                        tr(""), 1, 1, 0x0001, operate));
    // 122
    // 软件限位; 位图选择, 0, 不允许; 1, 允许;
    // bit0, xy移动;
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SETTING,
                                        122, 1, 0, PARA_VALUE_TYPE_SW,
                                        tr("Software limit: xy movement"),// 软件限位:xy移动
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr(""),0, 0, 0x0001, operate));
    // 123
    // 功能控制
    // bit0,断线检测允许	0,禁止	1,允许
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SETTING,
                                        123, 1, 0, PARA_VALUE_TYPE_SW,
                                        tr("Wire breakage detection allowed"),// 断线检测允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr(""), 0, 0, 0x0001, operate));
    // bit1,扎线报警允许	0,禁止	1,允许
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SETTING,
                                        123, 2, 0, PARA_VALUE_TYPE_SW,
                                        tr("Wire tie alarm allowed"),// 扎线报警允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr(""), 0, 0, 0x0001, operate));
    // bit2,工作结束夹布自动打开	0,禁止	1,允许
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SETTING,
                                        123, 3, 0, PARA_VALUE_TYPE_SW,
                                        tr("After work is completed, the fabric clamp will automatically open"),// 工作结束夹布自动打开
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr(""), 0, 0, 0x0001, operate));
    // bit3,起针松线		0,禁止	1,允许
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SETTING,
                                        123, 4, 0, PARA_VALUE_TYPE_SW,
                                        tr("Starting needle and loosening thread"),// 起针松线
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr(""), 0, 0, 0x0001, operate));
    // bit4,起针夹线		0,禁止	1,允许
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SETTING,
                                        123, 5, 0, PARA_VALUE_TYPE_SW,
                                        tr("Starting needle clamping thread"),// 起针夹线
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr(""), 0, 0, 0x0001, operate));
    // 124
    // 偏移点坐标有效标志; 0, 无效; 1, x有效; 2, y有效; 3, xy同时有效		默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_POSITION,
                                        124, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Offset point coordinate valid flag"),// 偏移点坐标有效标志
                                        0, 0, 3, 0, 0, tr(""), tr(""),
                                        tr("Invalid:0;X is valid:1;Y is valid:2;XY is valid:3"),//无效:0;X有效:1;Y有效:2;XY同时有效:3
                                        0, 0, 0x0001, operate));
    // 偏移点坐标X,单位0.01mm, 范围 -2147483648--2147483647
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_POSITION,
                                        125, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Offset X"),// 偏移点坐标 X
                                        0, S32_MIN, S32_MAX, 0, 2, "mm", tr(""),
                                        tr(""),0, 0, 0x0001, operate));
    // 偏移点坐标Y,单位0.01mm, 范围 -2147483648--2147483647
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_POSITION,
                                        126, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Offset Y"),// 偏移点坐标 Y
                                        0, S32_MIN, S32_MAX, 0, 2, "mm", tr(""),
                                        tr(""),0, 0, 0x0001, operate));
    // 127
    // 上料点坐标有效标志; 0, 无效; 1, x有效; 2, y有效; 3, xy同时有效		默认0
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_POSITION,
                                        127, 0, 0, PARA_VALUE_TYPE_LIST,
                                        tr("Loading point coordinate valid flag"),// 上料点坐标有效标志
                                        0, 0, 3, 0, 0, tr(""), tr(""),
                                        tr("Invalid:0;X is valid:1;Y is valid:2;XY is valid:3"),//无效:0;X有效:1;Y有效:2;XY同时有效:3
                                        0, 0, 0x0001, operate));
    // 上料点坐标X,单位0.01mm
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_POSITION,
                                        128, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Loading point coordinate X"),// 上料点坐标 X
                                        0, S32_MIN, S32_MAX, 0, 2, "mm", tr(""),
                                        tr(""),0, 0, 0x0001, operate));
    // 上料点坐标Y,单位0.01mm
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_POSITION,
                                        129, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Loading point coordinate Y"),// 上料点坐标 Y
                                        0, S32_MIN, S32_MAX, 0, 2, "mm", tr(""),
                                        tr(""),0, 0, 0x0001, operate));
    // 拉料起始位置,单位0.01mm
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_POSITION,
                                        130, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Starting position of material pulling"),// 拉料起始位置
                                        0, S32_MIN, S32_MAX, 0, 2, "mm", tr(""),
                                        tr(""),0, 0, 0x0001, operate));
    // 拉料结束位置,单位0.01mm
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_POSITION,
                                        131, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("End position of material pulling"),// 拉料结束位置
                                        0, S32_MIN, S32_MAX, 0, 2, "mm", tr(""),
                                        tr(""),0, 0, 0x0001, operate));
    // 132
    // 移框时动作允许	0,不允许		1,允许
    // bit0,松线允许
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SETTING,
                                        132, 1, 0, PARA_VALUE_TYPE_SW,
                                        tr("Allow for moving frames and loosening lines"),// 移框松线允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr(""), 0, 0, 0x0001, operate));
    // bit0,夹线允许
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_SETTING,
                                        132, 2, 0, PARA_VALUE_TYPE_SW,
                                        tr("Allow for frame movement and line clamping"),// 移框夹线允许
                                        0, 0, 1, 0, 0, tr(""), tr(""),
                                        tr(""), 0, 0, 0x0001, operate));

    // 更换X梭盘位置,单位0.01mm
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_POSITION,
                                        133, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Replacing the position of the X shuttle disc"),// 更换X梭盘位置
                                        0, S32_MIN, S32_MAX, 0, 2, "mm", tr(""),
                                        tr(""),0, 0, 0x0001, operate));

    // 更换Y梭盘位置,单位0.01mm
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_POSITION,
                                        134, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Replacing the position of the Y shuttle disc"),// 更换Y梭盘位置
                                        0, S32_MIN, S32_MAX, 0, 2, "mm", tr(""),
                                        tr(""),0, 0, 0x0001, operate));

    // 穿线点X,单位0.01mm
    m_allParasList.append(makeAParaItem(0,
                                        PARA_TYPE_WORK,
                                        MC_SORT_POSITION,
                                        135, 0, 0, PARA_VALUE_TYPE_INT,
                                        tr("Thread point X"),// 穿线点X
                                        0, S32_MIN, S32_MAX, 0, 2, "mm", tr(""),
                                        tr(""),0, 0, 0x0001, operate));

}

#define    MT_LX                0x0001    // X向移动电机
#define    MT_LY                0x0002    // Y向移动电机
#define MT_LMS                0x0003    // 主轴
#define MT_LND                0x0004    // 针
#define MT_LHK                0x0005    // 梭
#define MT_LR                0x0006    // 旋转
#define MT_LUR                0x0007    // 上旋转
#define MT_LDR                0x0008    // 下旋转
#define MT_LCB                0x0009    // 环带
#define MT_LP                0x000A    // 拉料电机(拉料,料斗收放料)
#define MT_LZ                0x000B    // 摆嘴电机


#define OT_FEEDPRESS			0x0001	// 进料压料升降
#define OT_CLAMPOPEN			0x0002	// 夹布开合
#define OT_CLAMPLOOSEN			0x0003	// 夹布松紧
#define OT_PULLPRESS1			0x0004	// 拉料压料1升降
#define OT_WIRESHELF1			0x0005	// 电阻丝料架1(正转 反转 停止)
#define OT_HEADLIFT			0x0006	// 机头升降
#define OT_FEEDWIRE			0x0007	// 放料电机
#define OT_FOOT				0x0008	// 小压脚升降
#define OT_LOOSEN			0x0009	// 松紧线
#define OT_CLIP				0x000A	// 夹面线
#define OT_UOIL				0x000B	// 机头加油
#define OT_FEEDLIFT			0x000C	// 送料辊升降
#define OT_CUTLIFT			0x000D	// 上剪刀升降
#define OT_UCUT				0x000E	// 上剪刀开合
#define OT_PENLIFT			0x000F	// 马克笔升降
#define OT_DCUT				0x0010	// 下剪刀开合
#define OT_PUSH				0x0011	// 扣线
#define OT_BLOW				0x0012	// 吹气
#define OT_DOIL				0x0013	// 旋梭加油
#define OT_PUSHSTRETCH			0x0014	// 扣线伸缩装置
#define OT_PULLPRESS2			0x0015	// 拉料压料2升降
#define OT_WIRESHELF2			0x0016	// 电阻丝料架2(正转 反转 停止)
#define OT_ZIGZAG                0x0017    // 摆嘴摆动
#define OT_PRESSWIRE            0x0018    // 压电阻丝

#define	OT_CHBOB_GRAB_OPEN		0x0070	// 换梭装置抓取	开合
#define	OT_CHBOB_SWAY_PUSH		0x0071	// 换梭装置摆动	伸缩
#define	OT_CHBOB_PUSH_PUSH		0x0072	// 换梭装置推动	伸缩
#define	OT_CHBOB_SPIN			0x0073	// 换梭装置旋转	伸缩

#define	UP_OPEN_ON			0x0001	// 上升、打开、放松、伸出
#define	DOWN_CLOSE_OFF			0x0002	// 下降、关闭、加紧、收回
#define	OT_ACTION			0x0003	// 动作

void ThickWiringMac::initOutCtrlList()
{
    m_allOutCtrlList.clear();
    int showPriority =1;
    //电机
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("X-direction moving motor"),MT_LX,// X向移动电机
                                             enableStr,true,OUTCONTROL_ENABLE,-1,-1,
                                             disableStr,true,OUTCONTROL_DISABLE,-1,-1,
                                             jogPStr,true,-1,OUTCONTROL_JOGP,OUTCONTROL_STOP,
                                             jogNStr,true,-1,OUTCONTROL_JOGN,OUTCONTROL_STOP,
                                             zeroStr,true,OUTCONTROL_ZERO,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Y-direction moving motor"),MT_LY,// Y向移动电机
                                             enableStr,true,OUTCONTROL_ENABLE,-1,-1,
                                             disableStr,true,OUTCONTROL_DISABLE,-1,-1,
                                             jogPStr,true,-1,OUTCONTROL_JOGP,OUTCONTROL_STOP,
                                             jogNStr,true,-1,OUTCONTROL_JOGN,OUTCONTROL_STOP,
                                             zeroStr,true,OUTCONTROL_ZERO,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Spindle motor"),MT_LMS,// 主轴电机
                                             enableStr,true,OUTCONTROL_ENABLE,-1,-1,
                                             disableStr,true,OUTCONTROL_DISABLE,-1,-1,
                                             jogPStr,true,-1,OUTCONTROL_JOGP,OUTCONTROL_STOP,
                                             jogNStr,true,-1,OUTCONTROL_JOGN,OUTCONTROL_STOP,
                                             zeroStr,true,OUTCONTROL_ZERO,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Needle motor"),MT_LND,// 针电机
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             jogPStr,true,-1,OUTCONTROL_JOGP,OUTCONTROL_STOP,
                                             jogNStr,true,-1,OUTCONTROL_JOGN,OUTCONTROL_STOP,
                                             zeroStr,true,OUTCONTROL_ZERO,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Shuttle motor"),MT_LHK,// 梭电机
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             jogPStr,true,-1,OUTCONTROL_JOGP,OUTCONTROL_STOP,
                                             jogNStr,true,-1,OUTCONTROL_JOGN,OUTCONTROL_STOP,
                                             zeroStr,true,OUTCONTROL_ZERO,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Rotating motors"),MT_LR,// 旋转电机
                                             enableStr,true,OUTCONTROL_ENABLE,-1,-1,
                                             disableStr,true,OUTCONTROL_DISABLE,-1,-1,
                                             jogPStr,true,-1,OUTCONTROL_JOGP,OUTCONTROL_STOP,
                                             jogNStr,true,-1,OUTCONTROL_JOGN,OUTCONTROL_STOP,
                                             zeroStr,true,OUTCONTROL_ZERO,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Upward rotating motor"),MT_LUR,// 上旋转电机
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             jogPStr,true,-1,OUTCONTROL_JOGP,OUTCONTROL_STOP,
                                             jogNStr,true,-1,OUTCONTROL_JOGN,OUTCONTROL_STOP,
                                             zeroStr,true,OUTCONTROL_ZERO,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Lower rotating motor"),MT_LDR,// 下旋转电机
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             jogPStr,true,-1,OUTCONTROL_JOGP,OUTCONTROL_STOP,
                                             jogNStr,true,-1,OUTCONTROL_JOGN,OUTCONTROL_STOP,
                                             zeroStr,true,OUTCONTROL_ZERO,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Ring motor"),MT_LCB,// 环带电机  没有归零
                                             "",false,-1,-1,-1,
                                             enableStr,true,OUTCONTROL_ENABLE,-1,-1,
                                             disableStr,true,OUTCONTROL_DISABLE,-1,-1,
                                             jogPStr,true,-1,OUTCONTROL_JOGP,OUTCONTROL_STOP,
                                             jogNStr,true,-1,OUTCONTROL_JOGN,OUTCONTROL_STOP));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Pulling motor"),MT_LP,// 拉料电机     这个动作位置更换,没有归零
                                             "",false,-1,-1,-1,
                                             enableStr,true,OUTCONTROL_ENABLE,-1,-1,
                                             disableStr,true,OUTCONTROL_DISABLE,-1,-1,
                                             jogPStr,true,-1,OUTCONTROL_JOGN,OUTCONTROL_STOP,
                                             jogNStr,true,-1,OUTCONTROL_JOGP,OUTCONTROL_STOP));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Swinging mouth motor"),MT_LZ,// 摆嘴电机
                                             enableStr,true,OUTCONTROL_ENABLE,-1,-1,
                                             disableStr,true,OUTCONTROL_DISABLE,-1,-1,
                                             jogPStr,true,-1,OUTCONTROL_JOGP,OUTCONTROL_STOP,
                                             jogNStr,true,-1,OUTCONTROL_JOGN,OUTCONTROL_STOP,
                                             zeroStr,true,OUTCONTROL_ZERO,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Manual material pulling"),MT_LYPB,// Y 手动拉料 环带
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             backStr,true,-1,OUTCONTROL_JOGP,OUTCONTROL_STOP,
                                             pulStr,true,-1,OUTCONTROL_JOGN,OUTCONTROL_STOP));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Linkage material return"),MT_LINKRE,// 联动退料
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             backStr,true,OUTCONTROL_PULLBACK,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Send resistance wire"),MT_LFW,// 送电阻丝
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,-1,OUTCONTROL_JOGP,OUTCONTROL_STOP,
                                             closeStr,true,-1,OUTCONTROL_JOGN,OUTCONTROL_STOP));



    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Swinging mouth"),OT_ZIGZAG,// 摆嘴摆动
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             swingoneStr,true,OUTCONTROL_OPEN,-1,-1,
                                             swingtwoStr,true,OUTCONTROL_CLOSE,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Piezoresistive wire"),OT_PRESSWIRE,//压电阻丝
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));

    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Feeding and pressing lifting"),OT_FEEDPRESS,//进料压料升降
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             ascendStr,true,OUTCONTROL_UP,-1,-1,
                                             descendStr,true,OUTCONTROL_DOWN,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Cloth clip opening and closing"),OT_CLAMPOPEN,//夹布开合
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Tightness of the cloth clip"),OT_CLAMPLOOSEN,//夹布松紧
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             release,true,OUTCONTROL_OPEN,-1,-1,
                                             tighten,true,OUTCONTROL_CLOSE,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("material pulling and pressing 1"),OT_PULLPRESS1,//拉料压料1
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             ascendStr,true,OUTCONTROL_OPEN,-1,-1,
                                             descendStr,true,OUTCONTROL_CLOSE,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Resistance wire material rack 1"),OT_WIRESHELF1,//电阻丝料架1(正转 反转 停止)
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             jogPStr,true,OUTCONTROL_OPEN,-1,-1,
                                             jogNStr,true,OUTCONTROL_CLOSE,-1,-1,
                                             stopStr,true,OUTCONTROL_COCOSTOP,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("material pulling and pressing 2"),OT_PULLPRESS2,//拉料压料2
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             ascendStr,true,OUTCONTROL_OPEN,-1,-1,
                                             descendStr,true,OUTCONTROL_CLOSE,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Resistance wire material rack 2"),OT_WIRESHELF2,//电阻丝料架2(正转 反转 停止)
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             jogPStr,true,OUTCONTROL_OPEN,-1,-1,
                                             jogNStr,true,OUTCONTROL_CLOSE,-1,-1,
                                             stopStr,true,OUTCONTROL_COCOSTOP,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Head lifting and lowering"),OT_HEADLIFT,//机头升降
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             ascendStr,true,OUTCONTROL_UP,-1,-1,
                                             descendStr,true,OUTCONTROL_DOWN,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Discharge motor "),OT_FEEDWIRE,//放料电机
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             jogPStr,true,-1,OUTCONTROL_JOGP,OUTCONTROL_STOP,
                                             jogNStr,true,-1,OUTCONTROL_JOGN,OUTCONTROL_STOP));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Small presser foot lifting"),OT_FOOT,//小压脚升降
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             ascendStr,true,OUTCONTROL_UP,-1,-1,
                                             descendStr,true,OUTCONTROL_DOWN,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Elastic thread"),OT_LOOSEN,//松紧线
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_CLOSE,-1,-1,
                                             closeStr,true,OUTCONTROL_OPEN,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Sandwich line"),OT_CLIP,//夹面线
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_CLOSE,-1,-1,
                                             closeStr,true,OUTCONTROL_OPEN,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Nose refueling"),OT_UOIL,//机头加油
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Feeding roller lifting"),OT_FEEDLIFT,//送料辊升降
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             ascendStr,true,OUTCONTROL_UP,-1,-1,
                                             descendStr,true,OUTCONTROL_DOWN,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Upper scissors lifting and lowering"),OT_CUTLIFT,//上剪刀升降
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             ascendStr,true,OUTCONTROL_UP,-1,-1,
                                             descendStr,true,OUTCONTROL_DOWN,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Upper scissors opening and closing"),OT_UCUT,//上剪刀开合
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Mark pen up and down"),OT_PENLIFT,//马克笔升降
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             ascendStr,true,OUTCONTROL_UP,-1,-1,
                                             descendStr,true,OUTCONTROL_DOWN,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Lower scissors opening and closing"),OT_DCUT,//下剪刀开合
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Buckle thread"),OT_PUSH,//扣线
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Blow air"),OT_BLOW,//吹气
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Spinning shuttle refueling"),OT_DOIL,//旋梭加油
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Wire buckle expansion device"),OT_PUSHSTRETCH,//扣线伸缩装置
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             stretchStr,true,OUTCONTROL_OPEN,-1,-1,
                                             recoverStr,true,OUTCONTROL_CLOSE,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Shuttle changing device grabbing"),OT_CHBOB_GRAB_OPEN,//换梭装置抓取 开合
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             openStr,true,OUTCONTROL_OPEN,-1,-1,
                                             closeStr,true,OUTCONTROL_CLOSE,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Swinging of shuttle changing device"),OT_CHBOB_SWAY_PUSH,//换梭装置摆动 伸缩
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             stretchStr,true,OUTCONTROL_OPEN,-1,-1,
                                             recoverStr,true,OUTCONTROL_CLOSE,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Shuttle changing device push"),OT_CHBOB_PUSH_PUSH,//换梭装置推动 伸缩
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             stretchStr,true,OUTCONTROL_OPEN,-1,-1,
                                             recoverStr,true,OUTCONTROL_CLOSE,-1,-1));
    m_allOutCtrlList.append(makeAOutCtrlItem(0,showPriority++,tr("Shuttle changing device rotation "),OT_CHBOB_SPIN,//换梭装置旋转 伸缩
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             "",false,-1,-1,-1,
                                             stretchStr,true,OUTCONTROL_OPEN,-1,-1,
                                             recoverStr,true,OUTCONTROL_CLOSE,-1,-1));

}

void ThickWiringMac::initShortCutList()
{
    m_allShortCutList.clear();
    int index = 1;
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("AllToZero"),"buttonFrameZero",FUN_ALLTOZERO));//全部归零
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("FrontBack"),"buttonForwardOrBack",FUN_FORWARDORBACK));// 快进快退
//    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("ProcessReset"),"buttonProcessReset",FUN_PROCESSRESET));//流程复位
//    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("Simulated"),"buttonSimulatedStatus",FUN_SIMULATED_STATUS));// 模拟缝纫


    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("msToAngle"),"buttonBackEmbPoint",FUN_MS_TO_ANGLE));//主轴去指定角度
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("wireMsRun"),"buttonBackFeedingPoint",FUN_WIRE_MS_RUN));//主轴研车
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("rotToAngle"),"buttonBackOffsetPoint",FUN_ROT_TO_ANGLE));//旋转电机去指定角度
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("autoPull"),"buttonBackStartPoint",FUN_AUTO_PULL));//自动拉料
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("cutUd"),"buttonManualTrim",FUN_CUT_UD));//剪底面线
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("cutWire"),"buttonBackStopPoint",FUN_CUT_WIRE));//剪电阻丝
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("gotoPullpos"),"buttonBackToOrigin",FUN_GOTO_PULLPOS));//回拉料起始点
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("jawWork"),"buttonBackWorkPoint",FUN_JAW_WORK));//夹布工作状态
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("jawFeed"),"buttonCommonFunction",FUN_JAW_FEED));//夹布上料状态
//    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("zigzagPos1"),"buttonBeadParas",FUN_ZIGZAG_POS1));//去摆动位1
//    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("zigzagPos2"),"buttonBeadParas",FUN_ZIGZAG_POS2));//去摆动位2
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("autoChange oneShut"),"buttonActionParas",FUN_AUTO_CHANGE_ONE_SHUT));//自动换一个梭
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("installFirst bobbin"),"buttonBottomDetect",FUN_INSTALL_FIRST_BOBBIN));//安装第一个梭壳
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("shutFrom plateToHead"),"buttonCoilParas",FUN_SHUT_FROM_PLATE_TO_HEAD));//将旋梭从梭盘拿到机头
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("shutFrom headToPlate"),"buttonCoilParas",FUN_SHUT_FROM_HEAD_TO_PLATE));//将旋梭从机头拿到梭盘
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("shutInto takePlate"),"buttonHeadEmb",FUN_SHUT_INTO_TAKE_PLATE));//进入更换梭盘状态
//    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("shutInto indxSta"),"buttonHardwareConfig",FUN_SHUT_INTO_INDX_STA));//进入缝纫状态
//    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("N/S Proofread"),"buttonAutoParas",FUN_MAINSHAFT_ADJUST));//针梭校对
//    m_allShortCutList.append(makeAShortCutItem(0, index++, tr("Set anchor"),"buttonSetAnchorPoint",FUN_SETANCHORPOINT));//定定位点
//    m_allShortCutList.append(makeAShortCutItem(0, index++, tr("Back anchor"),"buttonBackAnchorPoint",FUN_BACKANCHORPOINT));//回定位点
//    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("ypbMove"),"buttonManualChangeColor",FUN_YPB_MOVE));//手动拉料
    m_allShortCutList.append(makeAShortCutItem(0, index++, tr("Set start "),"buttonSetEmbPoint",FUN_SETSTARTPOINT));//定起始点
    m_allShortCutList.append(makeAShortCutItem(0, index++, tr("Back start"),"buttonBackEmbPoint",FUN_BACKSTARTPOINT));//回起始点
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("SetOffsetPoint"),"buttonSetAnchorPoint",FUN_SETOFFSETPOINT));// 定偏移点
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("backOffsetPoint"),"buttonBackOffsetPoint",FUN_BACKOFFSETPOINT));// 回偏移点
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("backWorkPoint"),"buttonBackEmbPoint",FUN_BACKWORKPOINT));// 回工作点
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("SetFeedPoint"),"buttonSetAnchorPoint",FUN_SETFEEDINGPOINT));// 定上料点
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("backFeedPoint"),"buttonBackAnchorPoint",FUN_BACKFEEDINGPOINT));// 回上料点
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("Back FeedtPoint"),"buttonBackStopPoint",FUN_GOTO_FEEDT));// 回穿线点
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("CountReset"),"buttonCommonFunction",FUN_COUNTRESET));//底线计数清零
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("FeedState"),"buttonCommonFunction",FUN_SHUT_FEED_STATE));//进入送料状态
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("TakeState"),"buttonCommonFunction",FUN_SHUT_BACK_STATE));//进入收料状态
    m_allShortCutList.append(makeAShortCutItem(0,index++,tr("shuttleline"),"buttonCommonFunction",FUN_SHUIILE_LINE));//梭芯底线显示

}

void ThickWiringMac::initAssistList()
{
    m_allAssistList.clear();

    m_allAssistList.append(makeAAssistItem(0,0x0001,tr("Signal"),"buttonSensor",ASSIST_SENSOR));//传感器信号
    m_allAssistList.append(makeAAssistItem(0,0x0002,tr("Action"),"buttonControlAction",ASSIST_CONTROLACTION));//控制动作
    m_allAssistList.append(makeAAssistItem(0,0x0003,tr("HMIUpgrade"),"buttonHMIUpgrade",ASSIST_HMIUPGRADE));//界面升级
    m_allAssistList.append(makeAAssistItem(0,0x0004,tr("MCUpgrade"),"buttonMCUpgrade",ASSIST_MCUPGRADE));//主控升级
    m_allAssistList.append(makeAAssistItem(0,0x0006,tr("ParaImport"),"buttonParaImport",ASSIST_PARAIMPORT));//参数导入
    m_allAssistList.append(makeAAssistItem(0,0x0007,tr("ParaExport"),"buttonParaExport",ASSIST_PARAEXPORT));//参数导出
    m_allAssistList.append(makeAAssistItem(0,0x0008,tr("SoftwareSet"),"buttonSoftwareSet",ASSIST_SOFTWARESET));//软件设置
    m_allAssistList.append(makeAAssistItem(0,0x0009,tr("Authorization"),"buttonSoftwareAuthor",ASSIST_AUTHORIZATION));//软件授权
    m_allAssistList.append(makeAAssistItem(0,0x0009,tr("WIFI"),"buttonWIFI",ASSIST_WIFI));//WIFI
    m_allAssistList.append(makeAAssistItem(0,0x000A,tr("Network"),"buttonNetworkManage",ASSIST_NETWORK));//网络管理
    m_allAssistList.append(makeAAssistItem(0,0x000C,tr("Time"),"buttonTimeSet",ASSIST_TIMESET));//时间设置
    m_allAssistList.append(makeAAssistItem(0,0x000F,tr("Version"),"buttonVersionInfo",ASSIST_MCVERSION));//版本信息
    m_allAssistList.append(makeAAssistItem(0,0x0014,tr("Root"),"buttonRoot",ASSIST_ROOT));//超级用户
    m_allAssistList.append(makeAAssistItem(0,0x0015,tr("HMIreturn"),"buttonActionSet",ASSIST_HMIBACKUPSUPGRADE));//界面还原

}

void ThickWiringMac::initPatternSetList()
{
    m_allPatternSetList.clear();

    m_allPatternSetList.append(makeAPatternSetItem(0,0x0001,tr("Para"),"buttonPatternPara",PATTERNSET_PATTERNPARA));//文件参数
    m_allPatternSetList.append(makeAPatternSetItem(0,0x0002,tr("Select"),"buttonPatternSelect",PATTERNSET_PATTERNSELECT));//文件选择
    m_allPatternSetList.append(makeAPatternSetItem(0,0x0004,tr("Import"),"buttonPatternImport",PATTERNSET_PATTERNIMPORT));//文件导入
    m_allPatternSetList.append(makeAPatternSetItem(0,0x0005,tr("Export"),"buttonPatternExport",PATTERNSET_PATTERNEXPORT));//文件导出
    m_allPatternSetList.append(makeAPatternSetItem(0,0x0006,tr("Delete"),"buttonPatternDelete",PATTERNSET_PATTERNDELETE));//文件删除

}

void ThickWiringMac::initParaSetList()
{
    m_allParaSetList.clear();

    m_allParaSetList.append(makeAParaSetItem(0,0x0001,tr("OperatPara"),"buttonPositionParas",PARASET_SETTING));//设置参数  //操作参数
    m_allParaSetList.append(makeAParaSetItem(0,0x0002,tr("ActionSet"),"buttonActionParas",PARASET_ACTION));//动作参数   //动作设定
    m_allParaSetList.append(makeAParaSetItem(0,0x0003,tr("SpeedPara"),"buttonSpeedParas",PARASET_SPEED));//速度参数  //速度控制参数
    m_allParaSetList.append(makeAParaSetItem(0,0x0004,tr("LimitPara"),"buttonDetectParas",PARASET_POSITION));// 位置参数  //限位参数
    m_allParaSetList.append(makeAParaSetItem(0,0x0005,tr("MCPara"),"buttonSettingParas",PARASET_DETECT));//设置参数    //机器参数
}

void ThickWiringMac::initSensorList()
{
    QList <SensorItem> sensorList;

    sensorList.append(makeASensorItem(0x0080, 0, tr("Needle parking spaces")));//针停车位
    sensorList.append(makeASensorItem(0x0030, 0, tr("Rotate the zero position on the nose")));//机头上旋转零位
    sensorList.append(makeASensorItem(0x0170, 0, tr("Wire breakage detection")));//断线检测
    sensorList.append(makeASensorItem(0x024D, 0, tr("Resistance wire discharge detection")));//电阻丝出料检测
    sensorList.append(makeASensorItem(0x0020, 0, tr("X zero position")));//X零位
    sensorList.append(makeASensorItem(0x0020, 1, tr("Y zero position")));//Y零位
    sensorList.append(makeASensorItem(0x0021, 0, tr("X deceleration")));//X降速
    sensorList.append(makeASensorItem(0x0021, 1, tr("Y deceleration")));//Y降速
    sensorList.append(makeASensorItem(0x0022, 0, tr("X negative limit")));//X负限位
    sensorList.append(makeASensorItem(0x0022, 1, tr("Y negative limit")));//Y负限位
    sensorList.append(makeASensorItem(0x0023, 0, tr("X positive limit")));//X正限位
    sensorList.append(makeASensorItem(0x0023, 1, tr("Y positive limit")));//Y正限位
    sensorList.append(makeASensorItem(0x0088, 0, tr("Shuttle parking space")));//梭停车位
    sensorList.append(makeASensorItem(0x0241, 2, tr("Pull and press material 1 high position")));//拉料压料1高位
    sensorList.append(makeASensorItem(0x0241, 0, tr("Pull and press material 2 high position")));//拉料压料2高位

    sensorList.append(makeASensorItem(0x0000, 0, tr("Start button")));//启动按钮
    sensorList.append(makeASensorItem(0x0001, 0, tr("Pause button ")));//暂停按钮
    sensorList.append(makeASensorItem(0x0002, 0, tr("Click the button")));//点按按钮
    sensorList.append(makeASensorItem(0x0007, 0, tr("Air pressure detection")));//气压检测
    sensorList.append(makeASensorItem(0x0240, 2, tr("Clamp tension detection")));//夹布拉紧检测
    sensorList.append(makeASensorItem(0x0240, 4, tr("Cloth opening detection")));//夹布打开检测
    sensorList.append(makeASensorItem(0x0240, 6, tr("High level of feed pressure")));//进料压料高位

    sensorList.append(makeASensorItem(0x0241, 2, tr("High level of material pulling and pressing")));//拉料压料高位
    sensorList.append(makeASensorItem(0x024C, 0, tr("High level one material storage ")));//储料1高位(电阻丝料架)
    sensorList.append(makeASensorItem(0x024C, 1, tr("Middle level one material storage ")));//储料1中位(电阻丝料架)
    sensorList.append(makeASensorItem(0x024C, 2, tr("Low level one material storage ")));//储料1低位(电阻丝料架)
    sensorList.append(makeASensorItem(0x024C, 3, tr("Machine head discharge high position ")));//机头放料高位
    sensorList.append(makeASensorItem(0x024C, 4, tr("Machine head discharge low position ")));//机头放料低位
    sensorList.append(makeASensorItem(0x0103, 1, tr("Wire tie alarm")));//扎线报警
    sensorList.append(makeASensorItem(0x0040, 0, tr("Head high position")));//机头高位
    sensorList.append(makeASensorItem(0x0042, 0, tr("Head low position ")));//机头低位
    sensorList.append(makeASensorItem(0x02B0, 0, tr("Shuttle in position detection")));//梭在位检测
    sensorList.append(makeASensorItem(0x02B0, 2, tr("Shuttle changing rotating extension position")));//换梭旋转伸出位
    sensorList.append(makeASensorItem(0x02B0, 3, tr("Shuttle rotation and retraction position")));//换梭旋转收回位
    sensorList.append(makeASensorItem(0x02B0, 4, tr("Shuttle changing push extension position")));//换梭推动伸出位
    sensorList.append(makeASensorItem(0x02B0, 5, tr("Shuttle changing and pushing to retract position")));//换梭推动收回位
    sensorList.append(makeASensorItem(0x02B0, 6, tr("Shuttle changing swing extension position")));//换梭摆动伸出位
    sensorList.append(makeASensorItem(0x02B0, 7, tr("Shuttle changing swing retraction position")));//换梭摆动收回位
    sensorList.append(makeASensorItem(0x0037, 0, tr("Head down rotation zero position")));//机头下旋转零位

    sensorList.append(makeASensorItem(0x024C, 5, tr("High level two material storage ")));//储料2高位(电阻丝料架)
    sensorList.append(makeASensorItem(0x024C, 6, tr("Middle level two material storage ")));//储料2中位(电阻丝料架)
    sensorList.append(makeASensorItem(0x024C, 7, tr("Low level two material storage ")));//储料2低位(电阻丝料架)


    //将机型所需的传感器列表替换到传感器整体列表中
    for(int i = 0; i < sensorList.size(); i++)
    {
        int byteaddr = sensorList[i].m_byte_offset;
        int bitaddr = sensorList[i].m_bit_offset;
        QString str = sensorList[i].m_name;
        int type = sensorList[i].m_type;

        int idx = byteaddr*8+bitaddr;
        if(idx < m_allSensorList.size())
        {
            m_allSensorList[idx].m_name = str;
            m_allSensorList[idx].m_type = type;
        }
    }
}

#define    ERR_INPUT_TIMEOUT        0x004B        // 进料超时

void ThickWiringMac::initErrorCodeAndStateList()
{
    m_allErrorCodeAndStateList.clear();

    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_MV_PARA,tr("0x0015") + tr("Motion parameter error")));           // 运动参数错误
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_MC_PARA,tr("0x0016")+ tr("Machine parameter error")));           // 机器参数错误
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_MS_NOT_SYNC,tr("0x0052") + tr("Needle shuttle not synchronized")));           // 针梭不同步
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_RO_NOT_SYNC,tr("0x0053") + tr("Rotation asynchronous")));              // 旋转不同步
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_NEEDLE_NOT_HIGH,tr("0x005A") + tr("Needle not in high position")));    // 机针不在高位
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_LIFT_TIMEOUT,tr("0x005F") + tr("Head lifting timeout")));      // 机头升降超时
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_X_LIT_POSI,tr("0x0023") + tr("X forward limit")));        // X正向限位
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_X_LIT_NEGA,tr("0x0024") + tr("X reverse limit")));        // X反向限位
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_Y_LIT_POSI,tr("0x0025") + tr("Y forward limit")));        // Y正向限位
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_Y_LIT_NEGA,tr("0x0026") + tr("Y reverse limit")));        // Y反向限位
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_OUT_RANGE,tr("0x0022") + tr("Target position out of range")));         // 目标位置越界
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_COOR_SYSTM,tr("0x0021") + tr("Coordinate system error")));        // 坐标系统错误
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_IN_PARA,tr("0x0017") + tr("Input parameter error")));           // 输入参数错误
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_HEAD_NOT_HIGH,tr("0x0055") + tr("Machine head not in high position")));     // 机头不在高位
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_MS_NOT_ZERO,tr("0x0050") + tr("Spindle not in zero position")));       // 主轴不在零位
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_HK_NOT_ZERO,tr("0x0051") + tr("Rotary shuttle not in zero position")));       // 旋梭不在零位
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_ROT_COOR_SYSTM,tr("0x00CB") + tr("Rotating motor coordinate system error")));       // 旋转电机坐标系统错误

    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_FEEDPRESS_NOT_HIGH,tr("0x0D20") + tr("Feed pressure not at high level")));       // 进料压料不在高位
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_FEEDPRESS_NOT_LOW,tr("0x0D21") + tr("Feed pressure not in low position")));       // 进料压料不在低位
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_PULLPRESS_NOT_HIGH,tr("0x0D22") + tr("Pulling and pressing materials are not at a high level")));       // 拉料压料不在高位
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_PULLPRESS_NOT_LOW,tr("0x0D23") + tr("Pulling and pressing materials are not in the low position")));       // 拉料压料不在低位
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_CLAMPCLOTH_NOT_TIGHTEN,tr("0x0D24") + tr("The cloth clip is not in the tension position")));       // 夹布不在拉紧位
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_CLAMPCLOTH_NOT_LOOSEN,tr("0x0D25") + tr("The cloth clip is not in the relaxed position")));       // 夹布不在放松位
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_CLAMPCLOTH_NOT_OPEN,tr("0x0D26") + tr("The cloth clip is not in the open position")));       // 夹布不在打开位
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_CLAMPCLOTH_NOT_CLOSE,tr("0x0D27") + tr("The cloth clip is not in the closed position")));       // 夹布不在关闭位
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_PEN_NOT_HIGH,tr("0x0D28") + tr("Brush not in high position")));       // 画笔不在高位
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_PEN_NOT_LOW,tr("0x0D29") + tr("Brush not in low position")));       // 画笔不在低位
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_UCUT_NOT_HIGH,tr("0x0D2A") + tr("The upper scissors are not in high position")));       // 上剪刀不在高位
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_UCUT_NOT_LOW,tr("0x0D2B") + tr("The upper scissors are not in the low position")));       // 上剪刀不在低位

    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_CHB_SWAY,tr("0x0219") + tr("Abnormal shuttle changing swing device")));       // 换梭摆动装置异常
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_CHB_PUSH,tr("0x021A") + tr("Abnormal shuttle changing pushing device")));       // 换梭推动装置异常
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_CHB_SPIN,tr("0x0230") + tr("Shuttle changing rotating device")));                // 换梭旋转装置
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_CHB_DPUSH,tr("0x0231") + tr("Shuttle changing buckle line expansion device")));       // 换梭扣线伸缩装置
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_WIRE_ALARM,tr("0x00C9") + tr("Wire tie alarm")));       // 扎线报警
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_CHB_SHUT,tr("0x021C") + tr("Shuttle shell detection abnormality")));        // 梭壳检测异常
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_HEAD_NOT_SAFE,tr("0x0060") + tr("The nose is not in a safe area")));        // 机头不在安全区域

    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_INSTALLMENT_OK,tr("0x0300") + tr("Password set successfully")));        // 密码设置成功
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_INSTALLMENT_FAIL,tr("0x0301") + tr("Password setting failed")));        // 密码设置失败
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_MS_COOR_SYSTM,tr("0x00CF") + tr("Spindle coordinate system error")));         // 主轴坐标系统错误
    m_allErrorCodeAndStateList.append(makeAErrorStateItem(ERR_INPUT_TIMEOUT,tr("0x004B") + tr("Feed timeout")));         // 进料超时


}
